package com.itheima.leetcode.od.b.sort;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.stream.Collectors;

/**
 * (B卷,100分)- 选修课（Java & JS & Python）
 * <p>
 * 题目描述
 * <p>
 * 现有两门选修课，每门选修课都有一部分学生选修，每个学生都有选修课的成绩，需要你找出同时选修了两门选修课的学生，先按照班级进行划分，班级编号小的先输出，每个班级按照两门选修课成绩和的降序排序，成绩相同时按照学生的学号升序排序。
 * <p>
 * 输入描述
 * <p>
 * 第一行为第一门选修课学生的成绩，
 * <p>
 * 第二行为第二门选修课学生的成绩，
 * <p>
 * 每行数据中学生之间以英文分号分隔，每个学生的学号和成绩以英文逗号分隔，
 * <p>
 * 学生学号的格式为8位数字
 * <p>
 * 2位院系编号+入学年份后2位+院系内部1位专业编号+所在班级3位学号
 * <p>
 * 学生成绩的取值范围为[0,100]之间的整数，
 * <p>
 * 两门选修课选修学生数的取值范围为[1-2000]之间的整数。
 * <p>
 * 输出描述
 * <p>
 * 同时选修了两门选修课的学生的学号，如果没有同时选修两门选修课的学生输出NULL，
 * <p>
 * 否则，先按照班级划分，班级编号小的先输出，每个班级先输出班级编号(学号前五位)，
 * <p>
 * 然后另起一行输出这个班级同时选修两门选修课的学生学号，学号按照要求排序(按照两门选修课成绩和的降序，成绩和相同时按照学号升序学生之间以英文分号分隔。
 * <p>
 * 用例
 * <p>
 * 输入	01202021,75;01201033,95;01202008,80;01203006,90;01203088,100
 * <p>
 * 01202008,70;01203088,85;01202111,80;01202021,75;01201100,88
 * <p>
 * 输出	01202
 * <p>
 * 01202008;01202021
 * <p>
 * 01203
 * <p>
 * 01203088
 * <p>
 * 说明
 * <p>
 * 同时选修了两选修课的学生01202021、01202008、01203088，这三个学生两门选修课的成绩和分别为150、150、185，
 * <p>
 * 01202021、01202008属于01202班的学生，按照成绩和降序，成绩相同时按学号升序输出的结果为01202008;01202021,
 * <p>
 * 01203088属于01203班的学生，按照成绩和降序，成绩相同时按学号升序输出的结果为01203088，
 * <p>
 * 01202的班级编号小于01203的班级编号，需要先输出。
 * <p>
 * 输入	01201022,75;01202033,95;01202018,80;01203006,90;01202066,100
 * <p>
 * 01202008,70;01203102,85;01202111,80;01201021,75;01201100,88
 * <p>
 * 输出	NULL
 * <p>
 * 说明	没有同时选修了两门选修课的学生，输出NULL.
 * <p>
 * 题目解析
 * <p>
 * 本题主要考察：字符串，数组，集合的操作，考察多条件排序。
 * <p>
 * 本题的逻辑如下：
 * <p>
 * 从输入的两行中，解析出学生信息（学号，班号，课程一得分，课程二得分）
 * <p>
 * 过滤出两门课程都有得分的学生
 * <p>
 * 将学生按照班号进行分别统计
 * <p>
 * 按照班号进行升序，然后打印班号，再将该班号下的学生按照：总分进行降序，总分相同，则继续按照学号升序，然后以“;”拼接同班学生的学号，进行打印
 * <p>
 * 难点主要在于第一步，如何从两行输入解析中得到一个完整学生的信息，这里我选用了字典结构，key为学生学号，value为学生信息，解析第二行输入时，可以检查字典是否已存在对应学号的key，若存在则再对应value下补充课程二得分。
 */
public class OptionalCourse {
    public static void main(String[] args) {
        /*Scanner sc = new Scanner(System.in);

        String s1 = sc.nextLine();
        String s2 = sc.nextLine();*/

        String s1 = "01202021,75;01201033,95;01202008,80;01203006,90;01203088,100";
        String s2 = "01202008,70;01203088,85;01202111,80;01202021,75;01201100,88";

        System.out.println(getResult(s1, s2));
    }

    public static String getResult(String s1, String s2) {
        // key是学号，value是学生对象
        HashMap<String, Student> students = new HashMap<>();

        Arrays.stream(s1.split(";"))
                .forEach(s -> {
                    String[] arr = s.split(",");
                    students.putIfAbsent(arr[0], new Student());
                    Student student = students.get(arr[0]);
                    student.sid = arr[0];
                    student.cid = arr[0].substring(0, 5);
                    student.score1 = Integer.parseInt(arr[1]);
                });
        Arrays.stream(s2.split(";"))
                .forEach(s -> {
                    String[] arr = s.split(",");
                    students.putIfAbsent(arr[0], new Student());
                    Student student = students.get(arr[0]);
                    student.sid = arr[0];
                    student.cid = arr[0].substring(0, 5);
                    student.score2 = Integer.parseInt(arr[1]);
                });


        // key是班号，value是该班级的学生集合
        HashMap<String, ArrayList<Student>> ans = new HashMap<>();

        // 过滤出有两个课程得分的学生
        students.values().stream()
                .filter(stu -> stu.score1 != -1 && stu.score2 != -1)
                .forEach(stu -> {
                    ans.putIfAbsent(stu.cid, new ArrayList<>());
                    ans.get(stu.cid).add(stu);
                });

        // 如果不存在这样的学生，则返回NULL
        if (ans.isEmpty()) {
            return "NULL";
        }

        ArrayList<String> result = new ArrayList<>();

        ans.keySet().stream()
                .sorted(String::compareTo) // 按照班号升序
                .forEach(
                        cid -> {
                            result.add(cid);

                            ArrayList<Student> clsStudents = ans.get(cid);
                            result.add(ans.get(cid).stream()
                                    .sorted(
                                            (a, b) ->
                                                    a.getSumScore() != b.getSumScore()
                                                            ? b.getSumScore() - a.getSumScore()
                                                            : a.sid.compareTo(b.sid)) // 同一班的学生按照总分降序，总分相同，则按照学号升序
                                    .map(student -> student.sid)
                                    .collect(Collectors.joining(";"))); // 打印同一班的学号，以分号分隔
                        });

        return result.stream().collect(Collectors.joining("\n"));
    }

    // 学生类
    static class Student {
        String sid; // 学号
        String cid; // 班号
        int score1 = -1; // 课程一 得分
        int score2 = -1; // 课程二 得分

        public Student() {
        }

        // 总分
        public int getSumScore() {
            return this.score1 + this.score2;
        }
    }
}